Pure fill via area extraction in a multi-wide object class design layout

ABSTRACT

In a multi-wide object class design layout, an automatic extraction of pure fill via areas (PFVA) among multi wide class objects treats the virtual boundaries of the wide objects differently than non-virtual boundaries to allow an extracted pure fill via area to extend across a virtual edge of a wide class object. An exemplary method is provided for deriving one or more pure fill via areas for geometries on a first layer in a design layout having multi-wide object classes on the first layer. The exemplary method includes forming a Current PFVA, initially as a PFVA for the geometries of the layer, and successively adjusting the Current PFVA for each higher wide object class corresponding to the geometries, to accommodate the respective enclosure rules for each higher wide object class.

CROSS REFERENCE TO RELATED APPLICATIONS

[0001] This application is related to the following co-pendingcommonly-assigned U.S. Patent Applications, each filed on even dateherewith, and each hereby incorporated by reference in its entirety:U.S. Application Number No. xx/xxx,xxx {Atty. Docket No. 004-7542} byMu-Jing Li, entitled “Correction of Spacing Violations Between Pure FillVia Areas in a Multi-Wide Object Class Design Layout”; U.S. ApplicationNumber No. xx/xxx,xxx {Atty. Docket No. 004-7655} by Mu-Jing Li and AmyYang, entitled “Redundant Via Rule Check in a Multi-Wide Object ClassDesign Layout”; U.S. Application Number No. xx/xxx,xxx {Atty. Docket No.004-7657} by Mu-Jing Li and Amy Yang, entitled “Via Enclosure Rule Checkin a Multi-Wide Object Class Design Layout”; and U.S. Application Numberxx/xxx,xxx {Atty. Docket No. 004-7660} by Mu-Jing Li and Amy Yang,entitled “Structure and Method for Separating Geometries in a DesignLayout into Multi-Wide Object Classes”.

BACKGROUND

[0002] 1. Field of the Invention

[0003] The present invention relates to error checking and manipulationof a design layout, and more particularly to computer aided designlayout and design rule verification of an integrated circuit designlayout, and use thereof for circuit fabrication.

[0004] 2. Background of the Invention

[0005] Design of an electronic circuit, for example, an integratedcircuit (IC), is a complicated and time consuming process. FIG. 1illustrates a typical design flow 80 of an integrated circuit devicefrom conception through the generation of a fabrication ready designlayout. Generally, design flow 80 commences with defining the designspecifications or requirements, such as required functionality andtiming, at step 82. The requirements of the design are implemented, forexample, as a netlist or electronic circuit description, at step 84. Theimplementation can be performed by, for example, schematic capture(drawing the design with a computer aided design tool) or moretypically, utilizing a high level description language such as VHDL,Verilog® and the like. The implemented design is simulated to verifydesign accuracy, at step 86. Design implementation and simulation areiterative processes. For example, errors found by simulation arecorrected by design implementation and re-simulated.

[0006] Once the design is verified for accuracy with simulation, adesign layout of the design is created, at step 88. The design layoutdescribes the detailed design geometries and the relative positioning ofeach design layer to be used in actual fabrication. The design layout isvery tightly linked to overall circuit performance (area, speed andpower dissipation) because the physical structure defined by the designlayout determines, for example, the transconductances of thetransistors, the parasitic capacitances and resistances, and the siliconarea which is used to realize a certain function. The detailed designlayout requires a very intensive and time-consuming design effort and istypically performed utilizing specialized computer aided design (CAD) orElectronic Design Automation (EDA) tools.

[0007] The design layout is checked against a set of design rules in adesign rule check (DRC), at step 90. The created design layout mustconform to a complex set of design rules in order, for example, toensure a lower probability of fabrication defects. The design rulesspecify, for example, how far apart the geometries on various layersmust be, or how large or small various aspects of the layout must be forsuccessful fabrication, given the tolerances and other limitations ofthe fabrication process. A design rule can be, for example, a minimumspacing amount between geometries and is typically closely associated tothe technology, fabrication process and design characteristics. Forexample, different minimum spacing amounts between geometries can bespecified for different sizes of geometries. DRC is a time-consumingiterative process that often requires manual manipulation andinteraction by the designer. The designer performs design layout and DRCiteratively, reshaping and moving design geometries to correct alllayout errors and achieve a DRC clean (violation free) design.

[0008] Circuit extraction is performed after the design layout iscompleted and error free, at step 92. The extracted circuit identifiesindividual transistors and interconnections, for example, on variouslayers, as well as the parasitic resistances and capacitances presentbetween the layers. A layout versus schematic check (LVS) is performed,at step 94, where the extracted netlist is compared to the designimplementation created in step 84. LVS ensures that the design layout isa correct realization of the intended circuit topology. Any errors suchas unintended connections between transistors, or missingconnections/devices, etc. must be corrected in the design layout beforeproceeding to post-layout simulation, step 96. The post-layoutsimulation is performed using the extracted netlist which provides aclear assessment of the circuit speed, the influence of circuitparasitics (such as parasitic capacitances and resistances), and anyglitches that can occur due to signal delay mismatches. Once post-layoutsimulation is complete and all errors found by DRC are corrected, thedesign is ready for fabrication and is sent to a fabrication facility.

[0009] As electronic circuit densities increase and technology advances,for example, in deep sub-micron circuits, skilled designers attempt tomaximize the utilization of the design layout and manufacturability andreliability of the circuit. For example, the density of a layer can beincreased, additional vias added to interconnection areas, and the like.Creation of a design layout and performing DRC become critical timeconsuming processes. Performing a DRC and manipulation of the designlayout often requires manual interaction from the designer. Morereliable and automated techniques for improving the design layout areconsistently desired.

[0010] In a modem semiconductor design technology, many metal layers areused to implement interconnections throughout an integrated circuit. Forsome integrated circuits, one or more polysilicon (poly) layers, or evenactive areas, are also used to implement interconnections. Vias are usedto connect from one such metal or polysilicon layer to another metal orpolysilicon layer. For example, a via may be used to connect a feature(i.e., a design geometry) on each of two metal layers. The lower one ofthe two layers is referred to as the landing metal layer and the upperone of the two layers is referred to as the covering layer. A viabetween a landing metal layer mt_(x) and the covering metal layermt_(x+1) is usually referred to as a v_(x) via (i.e., using the samesubscript designation as the landing metal layer).

[0011] Most design technologies include via enclosure rules to ensurethat both the landing metal and the covering metal enclose the via by acertain amount. In other words, such an enclosure rule ensures that eachmetal layer overlaps a via with a certain amount of extra metal, toensure that the via provides a good connection between the two metallayers once fabricated. The design rule specifying the extra amount ofmetal around each via may be referred to as a metal enclosure of a viadesign rule, and at times simply as a via enclosure design rule.

[0012] In a modern semiconductor design technology, especially for adeep sub-micron design, poly and metal layers which are used toimplement connections through vias apply different via enclosure rulesdepending on the width of the metal or poly in the vicinity of the via.When a via is placed in a wide metal area, it may need more metalenclosure than that of a via which is placed in a narrower metal area.When a via is partially in wide metal area and partially in non-widemetal area, it may need different metal enclosure in each differentarea. In general, as the design technology advances, more and more wideclasses of metal features may be used in a design layout, havingdifferent metal enclosure design rules for each wide metal class.Automated design rule checks to check such different enclosure rules formulti wide class objects without causing false errors (or false passes)have been difficult to develop, and additional improvements are needed.

[0013] Moreover, it may be desirable to apply different sets of rules togeometries on a given layer depending upon their relative size. Forexample, design layers which are used for implementing wires (e.g.,metal layers) may apply different design rules, such as spacing rules,to improve wafer fabrication results. Implementing different rule checksfor different width geometries may generate false errors and requiremanual intervention by skilled layout designers to determine whether the“error” should be corrected. Reliable, automated techniques are neededto facilitate design rule checking or design rule violation correctionon a multi wide class design.

SUMMARY

[0014] Because objects in each wide class are not real geometries, somederived wide class objects may contain virtual edges and vertices (i.e.,virtual boundaries). To achieve an automatic extraction of pure fill viaareas among multi wide class objects without generating erroneous areasor other false errors, the virtual boundaries of the wide objects arepreferably treated differently than non-virtual boundaries. Inparticular, an extracted pure fill via area is preferably allowed toextend across a virtual edge of a wide class object.

[0015] In an exemplary embodiment of the invention, a method is providedfor deriving one or more pure fill via areas (PFVA) for geometries on afirst layer in a design layout having multiple wide class objects on thefirst layer. The exemplary method includes forming a current PFVA,initially as a PFVA for the wide class w₀ objects (i.e., the geometriesof the layer), and successively adjusting the CPFVA for each higher wideclass of objects to accommodate the respective enclosure rules for eachhigher wide object class.

[0016] In some embodiments the w₀ PFVA may be formed by sizing the w₀objects inward by an associated via enclosure rule w₀ overV_(x). TheCPFVA may be adjusted by eliminating portions of the CPFVA lying insidethe w_(i) objects and lying within a distance equal to an associated viaenclosure rule w_(i) overV_(x) of any non-virtual boundary of the w_(i)objects, to thereby form a resultant CPFVA valid for up to w_(l) objects(w_(l) CPFVA). The last w_(n) CPFVA may be represented as the desiredPFVA for the first layer. In some embodiments, the first layer comprisesa metal layer of an integrated circuit design layout.

[0017] The foregoing is a summary and thus contains, by necessity,simplifications, generalizations and omissions of detail; consequently,those skilled in the art will appreciate that the summary isillustrative only and is not intended to be in any way limiting. Otheraspects, inventive features, and advantages of the present invention, asdefined solely by the claims, will become apparent in the non-limitingdetailed description set forth below.

BRIEF DESCRIPTION OF THE DRAWINGS

[0018] The present invention may be better understood, and its numerousobjects, features, and advantages made apparent to those skilled in theart by referencing the accompanying drawings.

[0019]FIG. 1, labeled prior art, illustrates an exemplary design flow100 for an integrated circuit device.

[0020] FIGS. 2A-2C are design layouts illustrating a geometry and twowide class objects derived therefrom.

[0021] FIGS. 3A-3E are design layouts which illustrate a technique forderiving a wide class object from a design geometry.

[0022] FIGS. 4A-4G are design layouts which illustrate a technique forderiving a wide class object from a design geometry havingnon-orthogonal edges.

[0023] FIGS. 5A-5E are design layouts which illustrate a technique forderiving an effective wide class object from a design geometry.

[0024] FIGS. 6A-6E are design layouts which illustrate a technique forselecting a whole edge of an object or geometry which partially abutsanother object or geometry.

[0025] FIGS. 7A-7D are design layouts which illustrate a technique forstretching non-virtual convex vertices of an object.

[0026] FIGS. 8A-8C are design layouts which illustrate the results of atechnique for performing a minimum spacing DRC check among wide classobjects which eliminates false errors otherwise resulting fromcorner-to-corner checks to virtual vertices, and otherwise resultingfrom spacing checks to virtual edges.

[0027] FIGS. 9A-9C are design layouts depicting vias placed within ametal geometry, and illustrate false errors which may result whenapplying wide object enclosure rules on the entire boundary of a wideobject.

[0028] FIGS. 10A-10C are design layouts depicting vias placed within ametal geometry, and illustrate false errors which may result whenapplying wide object enclosure rules on the boundary of the originalgeometry.

[0029] FIGS. 11A-11C are design layouts depicting vias placed within ametal geometry, and illustrate the operation and results of an exemplaryvia enclosure check algorithm.

[0030] FIGS. 12A-12C are design layouts depicting vias placed within ametal geometry, and illustrate the operation and results of anotherexemplary via enclosure check algorithm.

[0031] FIGS. 13A-13F are design layouts depicting a metal layer, andwhich illustrate a traditional technique for deriving pure fill viaareas (PFVAs) within the metal layer, and an exemplary technique forderiving pure fill via areas within the metal layer.

[0032] FIGS. 14A-14C are design layouts depicting a metal layer, andwhich illustrate another exemplary technique for deriving pure fill viaareas within the metal layer.

[0033] FIGS. 15A-15C are design layouts depicting a metal layer, andwhich illustrate an exemplary technique for correcting via spacingviolations between pure fill via areas and existing vias, and forcorrecting spacing violations between PFVAs within the metal layer.

[0034] The use of the same reference symbols in different drawingsindicates similar or identical items.

DETAILED DESCRIPTION

[0035] In a modern semiconductor design, it is desirable to applydifferent sets of rules to geometries (i.e., features) on a given layerdepending upon their relative size. For example, many design layers,especially those which are used for implementing gates (e.g.,polysilicon layers) and wires (e.g., metal layers) may be divided intodifferent classes depending upon their minimum width in any dimension.Objects in different classes may apply different design rules, such asspacing rules, via enclosure rules, and others, to improve waferfabrication results.

[0036] These derived intermediate geometries may be referred to asobjects to distinguish them from the original physically laid outgeometries (or shapes) hereafter. When checking these kinds of objects,it is important to consider the relationship between the artificialobjects and the real geometries, because only the real geometries willbe fabricated into a chip.

[0037] FIGS. 2A-2C illustrates a geometry 150, representing typically ametal or polysilicon feature, or other such material. As illustrated inFIG. 2A, a geometry 150 can be of irregular shape. The irregular shapeof a geometry may be its original drawn shape, or alternatively resultfrom a reshaping of the geometry to conform to design rules, allowancefor via placement, and other such design reasons.

[0038] Design rules are typically different for different sizedgeometries. For example, larger geometries require a larger amount ofspace between other geometries than is required by smaller geometries.Because the design rules are typically different for different sizedgeometries, geometries are often classified according to size.Classifying a shape such as geometry 150 can lead to several options.For example, geometry 150 can be classified according to its widestedge, applying worst case spacing requirements appropriate for thewidest edge. But this is not a desirable classification technique forspace restricted designs, for it may lead to needlessly large designlayouts.

[0039] Separating a Geometry Into Multi-Wide Classes

[0040] According to some embodiments of the present invention, a designlayout may have multiple wide classes defined, and a geometry can havemultiple wide class objects of varying edges and widths, w₀, w₁, w₂, . .. , w_(n) derived from it. Design rules are preferably applied to eachwide class object individually, resulting in a much more optimal layout.Wide class objects are derived from a geometry according to its shapeand size. A wide class of a particular geometry can have any number ofwide class objects, including zero. However, a particular geometry hasone and only one w₀ wide class object, representing the geometry. Thus,“w₀” and “geometry” are interchangeable. Further, a w₀ wide class objectdoes not need to be derived or calculated because all its edges arecoincident with the original geometry. As illustrated in FIG. 2A, thegeometry 150 has three wide classes, w₀, w₁, and w₂, each having oneobject. For clarity, the derived w₁ object is shown alone in FIG. 2B,and the derived w₂ object is shown alone in FIG. 2C.

[0041] FIGS. 3A-3E illustrates the deriving of wide class objects from ageometry. Typically, a sizing down and sizing up operation is performedon the edges of the geometry, for example, using an electronic designautomation (EDA) tool. If any portion of the geometry remains after thetwo sizing operations, the remaining portion(s) may be defined as a wideclass object(s). Such wide class objects are derived from thegeometries, and may be exactly the same as the geometries, or mayrepresent only a smaller portion of the geometry. As depicted in FIG.3B, the w₀ object 151 is sized down by a size factor size_f, whichsizing operation pushes each edge of the geometry inward by the sizingfactor, eliminating areas in the geometry with width less than the sizefactor amount in any dimension, and resulting in the object 152 shown inFIG. 3C. In other words, sizing down deletes any small areas (e.g.,“slivers”) of the geometries which are not wide enough to pass theoperation, such as region 153 of the w₀ object 151. The sizing upoperation then expands the remaining sized down objects outward by thesame sizing factor size_f, resulting in the object 154 shown in FIG. 3D.Thus, any small areas of the geometries are removed to form the wideclass object. Therefore, after the pair of sizing operations, theresulting derived wide class object can be of a different shape than theoriginal geometry. For a design with n wide classes, the sizing down andup operations may be repeated n times, each with the correspondingsizing factor appropriate for the wide class width amount. Wide classobjects may be identified as w₀, w₁, . . . w_(n) with w₀ having alledges coincident with the geometry, and w₁, . . . w_(n) as objects withincreasing wide class width amounts and, for example, increasingcorresponding minimum spacing rule amounts.

[0042] Wide class objects are not real geometries, but rather areartificial objects. The concept of a virtual edge may be used whenmanipulating geometries to meet design rules to manage certaincomplications introduced by deriving multiple wide class objects from ageometry. Although w₀ objects contain all real edges (i.e., non-virtualedges) which are coincident with the edges of the geometry, higher-orderwide class objects w₁, w₂, . . . , w_(n) can contain virtual edges. Avirtual edge is defined as an edge or an edge segment of an artificialobject that is not coincident with an edge of the geometry from which itwas derived. In other words, a virtual edge of a wide class w_(l) objectis “inside” the geometry (i.e., w₀ object) from which it was derived. Avirtual vertex is a vertex on the wide class object formed by at leastone virtual edge, but is not a real vertex on the geometry from which itwas derived. Virtual edges and virtual vertices may together be referredto as forming a virtual boundary, while conversely, non-virtual edges(i.e., real edges) and non-virtual vertices (i.e., real vertices) maytogether be referred to as forming a non-virtual boundary (i.e., realboundary). FIG. 3E illustrates a wide class w_(x) object 154 withvirtual edges 155 and a virtual vertex 156. Together, the virtual edges155 and virtual vertex 156 forms a virtual boundary.

[0043] Determining a proper sizing factor size_f is important to makesure that the EDA tool properly extracts the objects for each class. Thesizing factor is preferably set to a value slightly smaller thanone-half of the particular wide class definition. More preferably, thevalue should be one which “falls off” the design grid used for actualdesign geometries.

[0044] The preferred sizing factor may be viewed as being set toone-half of the wide class definition minus a slight offset value. Theoffset value is preferably the smallest number the EDA system canhandle, usually the system resolution, which is preferably ten timessmaller than the design grid, although other offset values, such as upto just less than one-half of the design grid, may also be used. In theexamples that follow, the offset value is set at one tenth of the designgrid, represented herein as TenthGrid. This offset is large enough forthe EDA system to count on it (i.e., to recognize the difference betweena coordinate value with it and without it), but small enough not to beable to mix with the real design data to cause any false errors.

[0045] The DIVA® physical layout verification environment, and itsassociated coding language, is a well known tool for manipulating designlayers and performing certain design rule checking of a design layout,and is a registered trademark of and is available from CADENCE DESIGNSYSTEMS, INC. of San Jose, Calif. An exemplary code segment written inDIVA language to perform sizing down and sizing up operations of a w₀layer is illustrated below.

[0046] 1 size_f=widex/2−TenthGrid

[0047] 2 wx=geomSize(geomSize(w0−size_f) size_f)

[0048] Line 1 defines the sizing factor size_f to be slightly less (onetenth of a grid) than ½ of the wide class width amount. Line 2 performsa sizing down operation (geomsize the geometry by a negative sizingfactor) and a sizing up operation (geomsize the sized down result by apositive sizing factor).

[0049] As an example, assume the following values: widex=7.0μ, designgrid=0.01μ, system resolution=0.001μ. Consequently, the value forTenthGrid=design grid/10=0.001μ,size_f=widex/2−TenthGrid=7.0/2−0.001=3.499μ, size_f*2=3.499*2=6.998μ.Because there can only be geometries with width 6.99μ or less and 7.00μor greater, it is impossible for an object or geometry within an on-griddesign layout to have a width of 6.998μ.

[0050] All the geometries in w₀ which is 6.99 or less will be removedwhen the inner operation geomSize (w0−3.499) is performed, because 3.499is bigger than 6.99/2=3.495. Those geometries with width 7.00 or greatersurvive this operation, because 7.00/2=3.5>3.499. Therefore, when theouter operation is performed, those original w₀ objects having a minimumwidth >=7.0 are written to the derived layer wx. As stated above, otheruseful values for the size factor include values as high as 3.496, whichrepresents one-half the wide class definition (3.500) minus “just less”than one-half the design grid value (0.005).

[0051] The above description is valid for orthogonal geometries. When ageometry contains non-orthogonal (i.e., “slant”) edges, an extra step ofANDing the result with the original geometry may be performed to ensurethat the resulting object is correct. Referring now to FIG. 4A, anoriginal geometry 171 with two slant edges is shown.

[0052]FIG. 4B shows that during the sizing down operation, every edgegets pushed inwards by the size factor, resulting in the intermediateobject 174 (shown in FIG. 4C). As can be seen, the upper right cornerslant edge 172 is farther away from the sized object 174 than the sizefactor. Therefore, this slant edge 172 contributes nothing to theintermediate object 174. In other words, it would be lost in thesubsequent sizing up operation. As is apparent in FIG. 4C, the edges inthe upper right corner of the sized intermediate object 174 areperpendicular, and any slant edge from the original geometry 171 hasvanished. In contrast, the lower left slant edge 173 is long enoughthat, even when sized inward by the size factor, a slant edge results inthe lower left corner of the intermediate object 174.

[0053]FIG. 4D shows how the sized down object 174 gets sized up by thesame sizing factor, and FIG. 4E shows the erroneous object 175 thatresults after this sizing up operation. The resultant object 175contains an extra part 177 in the upper right corner, which is a sideeffect of the sizing down and sizing up operation performed upon ageometry which contains non-orthogonal (i.e., “slant”) edges. Thiserroneous portion may be removed by ANDing the original geometry 171with the sized-up object 175, resulting in wide class object 176 asshown in FIG. 4F.

[0054]FIG. 4G illustrates a graphical method to determine whether thisslant edge side effect will happen. First, extend the perpendicularedges which are connect to a slant edge to form a right angle corner.The slant edge and the edge extension segments together form a testtriangle. Next, draw a test circle which is tangent to both edges oredge extension segments with the radius equal to the sizing factor, andcheck to see whether the test triangle is overlapping with any portionof the test circle. If the test triangle is not overlapping with thetest circle (as shown in the upper right corner), the slant edge willdisappear during the size down/size up operation. However, if the testtriangle does overlap the test circle, for example as shown in the lowerleft corner, the slant edge will not disappear during the size down/sizeup operation. Consequently, if a design layout may contain slant edges,an additional step is preferably performed to AND the intermediateresult (e.g., geometry 175) with the original geometry to get the finalwide class objects.

[0055] The resultant objects covered thus far are the results of EDAtool, which may be referred to as mathematical wide objects. Becausesome geometries may contain small portions which are filtered from wideobjects mathematically, but which portions may still behave with wideobject characteristics based on the process, additional correctionfactors are preferably considered to derive the effective wide objects.For example, to better reflect processing characteristics of suchgeometries, it may be advantageous to adjust the wide objects by acertain correction threshold to reclaim some small areas of the geometryjust outside the wide objects and otherwise excluded from the wideobjects. The particular value of the correction threshold is preferablydetermined to accommodate the semiconductor or mask-making processemployed. In one embodiment, if an area is butting with (i.e., touching)the wide object and its width is smaller than the correction threshold,it should be treated as part of the wide object, even though“mathematically” it is not part of the wide object (i.e., it is smallerthan the size factor corresponding to the wide object class). Aneffective wide object is actually a combination of those portions havingat least a certain minimum width, and an adjustment, after applying acorrection factor, to add back in certain small features otherwiseexcluded. FIGS. 5A-5E depicts a geometry 186 having a smaller portion188 similar to that shown in FIG. 3A, but also having a small portion187. The geometry 186 is sized down to generate the sized intermediateobject 190, and then sized up to form the wide class object 191. Buthere the wide class object 191 is sized by a correction factor to form aperipheral region 193 between the wide class object 191 and the sizedwide class object 192, and any additional portion of the geometry 186which falls wholly within this peripheral region 193 is added to thewide class object 191 to form the effective wide class object 194. Thesmall area 187 is included within the effective wide class object 194because it lies completely inside the correction threshold 192.

[0056] In general, if we have wide class definition of wide₀, wide₁,wide₂, . . . , wide_(n), we can represent the wide object sets as w₀,w₁, w₂, . . . , w_(n). Among them, w₀ is a special object set whichrepresents all original geometries. With these definitions, an exemplaryalgorithm for separating a design layer, such as metal, into n differentwide classes may be described in greater detail. Those wide object setshave the following relationship: w₀⊃w₁⊃w_(i)⊃w_(n). An exemplaryalgorithm for deriving mathematical wide object classes is as follows:

[0057] 1. Represent original geometries by the w₀ set (i.e., representeach original geometry as a w₀ object).

[0058] 2. Apply a wide₁ test on the w₀ objects to generate the initialw₁ set. (All objects in w_(i) can pass the wide_(i)test.)

[0059] 3. Perform AND operation on the initial w₁ set and the w₀ set togenerate the w₁ set, to prevent erroneous over-sizing up when w₀ objectscontain slant edges. If the design layout is orthogonal, then this stepis not needed.

[0060] 4. Apply a wide₂ test on the w₁ objects to generate the initialw₂ object set. All objects in w₂ can pass the wide₂ test. Any objectwhich could not pass the wide₁ test will never pass the wide₂ test. Thatis, a w₂ object must be contained within (i.e., having boundariescoincident with or inside) a w₁ object.

[0061] 5. Perform AND operation on the initial w₂ set and the w₀ set togenerate the w₂ object set, to prevent erroneous over-sizing up when w₀objects contain slant edges. If the design layout is orthogonal, thenthis step is not needed.

[0062] While each successive wide class may be computed directly fromthe w₀ set, it is sufficient (and more computationally efficient) tocalculate each successive wide class from the preceding wide class. Inother words, the preferred algorithm calculates wide class from thelowest numbered to the highest numbered (widest class). In general, toget w_(n) class objects, the wide_(n) test only need be performed onw_(n−1) class objects, because higher classes of wide objects must becontained in each lower classes of wide objects. This improvesperformance of the wide class separation process as each successive wideclass set generally has fewer objects in the set than its predecessorset. This may be generalized as follows: Apply wide_(i) test on thew_(i−1) object set to generate the initial w_(i) set. Then, if thedesign is non-orthogonal, perform an AND operation on the initial w_(l)set and the w₀ set to generate the w_(i) set. All objects in w_(i) canpass the wide_(i) test. In general, any object which could not pass thewide_(i−1) test will never pass the wide_(i) test. That is, a w_(i)object must be coincident with or inside a w_(i−1) object, and must becoincident with or inside a w_(i−2) object, . . . , and also must becoincident with or inside a w₀ object.

[0063] To derive the effective wide objects from the mathematical wideobjects, the above algorithm may be extended in an exemplary fashion asfollows:

[0064] 1. Use the above algorithm to get mathematical w_(i) classobjects.

[0065] 2. Get all w₀ class objects which are overlapping with the w_(i)objects.

[0066] 3. Deduct the w_(i) objects from the selected w₀ objects.

[0067] 4. Perform a wide test with a size factor set slightly smallerthan the w_(i) correction factor or threshold.

[0068] 5. Select all the objects which do not pass this wide test (i.e.,are smaller than the correction factor) and which completely fall withina distance equal to the correction factor from the w_(i) objects.

[0069] 6. Merge the above selected objects to the mathematical w_(i)objects to get effective w_(i) objects.

[0070] An exemplary algorithm for separating a metal layer into threewide classes w₁, w₂, and w₃ (in addition to the original geometriesbeing represented by the w₀ class) may be implemented as follows:

[0071] 1 w0=geomCat(mt_good)

[0072] 2 size_f=Mtwide1/2−TenthGrid

[0073] 3 w1=geomSize(geomSize(w0−size_f) size_f)

[0074] 4 w1=geomAnd(w0 w1)

[0075] 5 non₁₃ w1=geomAndNot(geomOverlap(w0 w1) w1)

[0076] 6 size_f=w1_cf/2−TenthGrid

[0077] 7 eff_w=geomAndNot(non_w1 geomSize(geomSize(non_w1−size_f)size_f))

[0078] 8 eff_w=geomInside(eff_w geomSize(w1 w1_cf))

[0079] 9 eff_w1=geomOr(w1 eff_w)

[0080] 10 size_f=MtWide2/2−TenthGrid

[0081] 11 w2=geomSize(geomSize(w1−size_f) size_f)

[0082] 12 w2=geomAnd(w0 w2)

[0083] 13 non_w2=geomAndNot(geomOverlap(w0 w2) w2)

[0084] 14 size_f=w2_cf/2−TenthGrid

[0085] 15 eff_w=geomAndNot(non_w2 geomSize(geomSize(non_w2−size_f)size_f))

[0086] 16 eff_w=geomInside(eff_w geomSize(w2 w2_cf))

[0087] 17 eff_w2=geomOr(w2 eff_w)

[0088] 18 size_f=MtWide3/2−TenthGrid

[0089] 19 w3=geomSize(geomSize(w2−size_f) size_f)

[0090] 20 w3=geomAnd(w0 w3)

[0091] 21 non_w3=geomAndNot(geomOverlap(w0 w3) w3)

[0092] 22 size_f=w3_cf/2−TenthGrid

[0093] 23 eff_w=geomAndNot(non_w3 geomsize(geomSize(non_w3−size_f)size_f))

[0094] 24 eff_w=geomInside(eff_w geomSize(w3 w3_cf))

[0095] 25 eff_w3=geomOr(w3 eff_w)

[0096] In lines 2-4, the mathematical wide class w₁ is derived from w₀objects, following the above-described algorithm. Line 5 selects all w₀class objects which are overlapping with the w₁ objects, and deducts thew₁ objects from the selected w₀ objects to generate non-w₁ objects.Lines 6-7 performs a wide test on the selected non-w₁ objects using asize factor equal to one-half the w₁ correction factor minus atenthgrid. Line 8 selects those non-w₁ objects falling within a w₁correction factor of the w₁ objects, and line 9 merges this with themathematical w₁ objects to generate the effective w₁ objects. Lines10-17 follow analogously for generating effective wide class w₂ objects,and lines 18-25 likewise follow analogously for generating effectivewide class w₃ objects.

[0097] The effective wide class objects form the foundation of manydesign rule checks or corrections, or design construction operations,and may thus define the virtual edges and virtual vertices. However, forother design rule checks, the use of wide class objects may refer to themathematical wide classes described above. Unless the context is clear,wide class objects need only refer to mathematical wide class objects,although such use may also refer to effective wide class objects.

[0098] In an exemplary design layout, three wide class definitions maybe utilized for a metal layer, in addition to the w₀ objects (i.e., theoriginal geometries). A wide class w₁ object may represent any portionof the geometry wider than 0.43μ. A wide class w₂ object may representany portion of the geometry wider than 2.19μ, and a wide class w₃ objectmay represent any portion of the geometry wider than 3.90μ. Exemplarycorrection factors corresponding to each object class may be 0.04μ forthe w₁ objects, 0.12μ for the w₂ objects, and 0.18μ for the w₃ objects.Exemplary minimum spacing rules corresponding to each object class maybe 0.18μfor the w₀ objects, 0.22μ for the w₁ objects, 0.41μ for the w₂objects, and 0.84μ for the w₃ objects.

[0099] Transforming Between a Geometry and an Edge to Stretch an EdgeSegment From a Vertex

[0100] In the design rule check or DRC violation correction process,especially when dealing with multi wide class designs, we often need tostretch two edge segments from the vertex where they meet. In existingEDA tools, there is no such function available, so achieving such acapability is key to the success of implementing all kinds of corner tocorner DRC check and DRC correction algorithms. Finding the locationwhere two edge segments touch each other, determining whether a vertexis a convex one or a concave one, and stretching the segments onlystarting from the vertex and outwards or inwards, are technicaldifficulties which may be overcome using a transformation techniquebetween shapes and edges. By using these techniques, available EDAoperations may be utilized to build a complex function such asstretching edges from a convex vertex by a certain amount.

[0101] In a DRC extraction, we typically have two type of selections. Ageometry selection is performed to select certain type of geometrieswhich meet one or more specific conditions. In this case, the geometriesselected are complete geometries even if only part of the geometry meetsthe conditions. In contrast, an edge selection is performed to selectcertain type of geometry edges or edge segments which meet one or morespecific conditions. In this case, only the edges or the part of theedge segments which meet the conditions are typically selected.Sometimes, we want to select a whole edge or edge segment, but only partof the edge meets the conditions. This is a particular difficulty inimplementing some of the design rule check or violation corrections,especially for those designs with multi wide metal class andcorner-corner spacing rules.

[0102] To resolve this technical difficulty, we can take advantage ofthe fact that geometries are selected in their entirety, to transform anedge selection problem into a geometry selection problem. By using theselected geometries, we can then get the whole edge or edge segment wewant. Conversely, we can also take advantage of the fact that edges maybe partially selected to transform a whole geometry selection probleminto an edge selection problem and therefore, to a partial geometryselection.

[0103] It is important to transform an edge or edge segment into ageometry which is under full control, but which will not cause any falseselection. Preferably, TenthGrid width boxes are created from the edges,although a box having a width of a minimum resolution of the CAD tool isalso contemplated. Such a TenthGrid width box contains the followingadvantages or features:

[0104] 1. At least two of the four edges of this kind of box are oflength TenthGrid, so part of the geometry is measurable. In an extremecase, it is a TenthGrid square with all four edges of length TenthGrid.

[0105] 2. One of the other two edges is the original edge or edgesegment, and the remaining edge is pushed out by TenthGrid.

[0106] 3. This kind of geometry will never be mixed with a real designgeometry, because a TenthGrid box has two vertices off-grid.

[0107] With these features as a bridge, we can go through theedge-to-geometry and geometry-to-edge selections back and forth toselect the whole edge or edge segment we want. FIGS. 6A-6E illustratehow such a method works for a very simple case. In this example, thereare two different geometries A and B, and they are butting each other.What we want to do is to find (i.e., select) the complete edge ongeometry A (also labeled 250) which is partially butting geometry B(also labeled 251). This may be accomplished by the following exemplaryalgorithm:

[0108] 1. Select the edge segment on A which is butting B (e.g.,resulting in segment 252 shown in FIG. 6B). Although segment 252 it ispart of one edge of A, it does not represent the complete edge on A. Asdescribed below, the complete edge may be identified by performing anedge to geometry transformation.

[0109] 2. Size the butting edge segment by TenthGrid to form an EdgeSegment TenthGrid Box (labeled 254 in FIG. 6C), thus transforming thebutting edge segment 252 into a geometry 254 of the same length.

[0110] 3. Get all edges from A and sizing them outward also by TenthGridto form Edge TenthGrid Boxes (labeled 256 in FIG. 6C), thus transformingthe geometry A edges into respective geometries.

[0111] 4. Select the geometry A Edge TenthGrid Box which is coincidentwith (i.e., overlaps) the butting Edge Segment TenthGrid Box. Thedesired edge of the original A geometry 250 is contained both in theselected Edge TenthGrid Box 258 and in the original A geometry 250.

[0112] 5. Select the edge on geometry A which is butting the selectedEdge TenthGrid Box 258, thus performing a geometry to edge transform toget the desired edge. The final resultant edge 260 is shown in FIG. 6E.

[0113] In the above example, the term “geometry” is used in contrast toan “edge”, and is not to be taken to presume the algorithm must operateon original shapes or geometries in the design layout. Rather, thealgorithm may operate on any original geometry or derived objects.

[0114] An exemplary use of such an edge-to/from-geometry transformationtechnique is an algorithm which outputs the stretched segments from theinput edge segments which are forming a convex vertex. This exemplaryalgorithm can be widely used in other corner-to-corner spacing rulecheck or DRC violation correction algorithms.

[0115] The exemplary algorithm takes BaseClass, StchSize, and InEdge asinputs to specify the base class objects where the vertices areresident, the stretch amount, and the input edge segments respectively.The InEdge is an edge segment set which is used to find the convexvertices created by any two of them and to stretch them outwards fromthe vertices, and they can be in a different class from BaseClass. Forexample, the InEdge segments may represent non-virtual edges of a higherorder object class relative to the BaseClass objects, which mayrepresent w₀ objects.

[0116] The exemplary algorithm described above may be implementedstraightforwardly in DIVA code to stretch edges at convex vertices asfollows:

[0117] 1 edge_tenth_box=geomSize(InEdge TenthGrid)

[0118] 2 tenth_edge=geomGetLength(edge_tenth_box length==TenthGrid)

[0119] 3 tenth_box=geomSize(tenth_edge TenthGrid)

[0120] 4 v_tenth_box=geomAvoiding(tenth_box BaseClass)

[0121] 5 v_but_box=geomSize(tenth_edge−TenthGrid)

[0122] 6 v_tenth_box=geomButting(v_tenth_box v_but_box keep==2)

[0123] 7 edge_v_edge_box=geomButting(edge_tenth_box v_tenth_box)

[0124] 8 edge_v_edge=geomGetEdge(edge_v_edge_box butting InEdge)

[0125] 9 edge_v_stch=geomStretch(edge_v_edge StchSize)

[0126] 10 edge_v_stch=geomAndNot(edge_v_stch edge_v_edge)

[0127] 11 edge_v_stch_box=geomSize(edge_v_stch TenthGrid)

[0128] 12 edge_v_stch_box=geomButting(edge_v_stch_box v_tenth_box)

[0129] 13 edge_v_stch=geomGetEdge(edge_v_stch_box butting edge_v_stch)

[0130] 14 edge_v_stch=geomStretch(edge_v_stch TenthGrid)

[0131] 15 edge_v_stch=geomOr(edge_v_stch)

[0132] 16 edge_v_stch=geomStretch(edge_v_stch−TenthGrid)

[0133] The above code statements represent a “convex stretch” modulethat may be referred to as Convex_Stch. rul by other code segmentsdescribed herein. The operation of this exemplary algorithm may bedescribed in reference to FIGS. 7A-7D, which show an object 271representing a BaseClass object (e.g., a w₀ object of a given layer).Also depicted are a set of edges 272 representing the InEdge set ofedges (e.g., representing non-virtual edges of a higher-order objectclass of the w₀ object).

[0134] The operation of this exemplary algorithm, as represented by theabove code module, can be described as follows:

[0135] 1. Size the input edge InEdge outward by TenthGrid to form EdgeTenthGrid Boxes (labeled 274) having a width of TenthGrid. (line 1 ofthe code module)

[0136] 2. Get all edges from the just created Edge TenthGrid Boxes withlength equal to TenthGrid, labeled 274. (code module line 2)

[0137] 3. Size these TenthGrid length edges outward by TenthGrid to formTenthGrid Squares (labeled 276) which, as described below, serve a veryimportant role in locating the proper stretched segments. (code moduleline 3)

[0138] 4. Select those TenthGrid Squares which are not contained withinBaseClass objects. (code module line 4) In other words, only thoseTenthGrid Squares which share a corner with a convex vertex of aBaseClass object are selected.

[0139] 5. Select those Edge TenthGrid Boxes which are butting aTenthGrid Square. (code module lines 5-7) These TenthGrid Squares mustbe butting exactly two Edge TenthGrid Boxes. This step ensures that therelated Edge TenthGrid Boxes are touching at least one convex vertex.For example, TenthGrid Square 280 abuts both Edge TenthGrid Boxes 281and 282, while TenthGrid Square 278 abuts both Edge TenthGrid Boxes 283and 284. Therefore, both edges which form the vertex are non-virtualedges. Some of the Edge TenthGrid Boxes might be butting one TenthGridSqaure at each end. For example, TenthGrid Square 279 abuts only oneEdge TenthGrid Box 274.

[0140] 6. Select the original edge segments from the Edge TenthGridBoxes which are butting TenthGrid square boxes (selected edges labeledas 285 in FIG. 7B) (code module line 8).

[0141] 7. Stretch the selected edges 285 by StchSize (code module line9), and keep only the Stretched Segments by deducting the selected edges285 from the stretched edges (code module line 10).

[0142] 8. Size the stretched segments inward (of the original geometry)by TenthGrid to form Stretched Segment TenthGrid Boxes, labeled as 286in FIG. 7C. (code module line 11)

[0143] 9. Select only those Stretched Segment TenthGrid Boxes which arebutting the TenthGrid Squares (code module line 12), because when anedge gets stretched, it is stretched at both ends evenly, so we needfilter out those Stretched Segment TenthGrid Boxes (e.g., StretchedSegment TenthGrid Boxes 287) which are not butting a TenthGrid Square.

[0144] 10. Finally, select edges from those remaining Stretched SegmentTenthGrid Boxes which are butting the Stretched Segments (code moduleline 13), so the resultant stretched segments will have the same facingdirection as those original edges in the InEdge.

[0145] 11. Because the Stretched Segment TenthGrid Boxes could be apolygon when one box crosses another, so the edges might be broken byTenthGrid at the point where they are crossing. To resolve the sideeffect, we then stretch the selected edges by Tenth Grid to close thepossible gap (code module line 14), merge the segments (because edgeswill not be automatically merged as geometries do) (code module line15), and then stretch the merged segments by—TenthGrid to outputcomplete stretched segments 288 shown in FIG. 7D. (code module line 16)

[0146] The following exemplary rule module stretches edges at a concavevertex, and also uses TenthGrid box techniques to transform geometriesand edges extensively.

[0147] 1 edge_tenth_box=geomSize(InEdge−TenthGrid)

[0148] 2 tenth_edge=geomGetLength(edge_tenth_box length==TenthGrid)

[0149] 3 tenth_box=geomSize(tenth_edge TenthGrid)

[0150] 4 v_tenth_box=geomButtOrOver(tenth_box BaseClass)

[0151] 5 v_but_box=geomsize(tenth_edge−TenthGrid)

[0152] 6 v_tenth_box=geomButting(v_tenth_box v_but_box keep==2)

[0153] 7 edge_v_edge_box=geomButting(edge_tenth_box v_tenth_box)

[0154] 8 edge_v_edge=geomGetEdge(edge_v_edge_box coincident InEdge)

[0155] 9 edge_v_stch=geomStretch(edge_v_edge StchSize)

[0156] 10 edge_v_stch=geomAndNot(edge_v_stch edge_v_edge)

[0157] 11 edge_v_stch_box=geomSize(edge_v_stch TenthGrid)

[0158] 12 edge_v_stch_box=geomButting(edge_v_stch_box v_tenth_box)

[0159] 13 edge_v_stch=geomGetEdge(edge_v_stch butting edge_v_stch_box)

[0160] 14 edge_v_stch=geomStretch(edge_v_stch TenthGrid)

[0161] 15 edge_v_stch=geomOr(edge_v_stch)

[0162] 16 edge_v_stch=geomStretch(edge_v_stch−TenthGrid)

[0163] The difference between the convex and concave cases is that adifferent type of TenthGrid square gets used. The exemplary code isidentical except for three differences, which may be found at line 1(algebraic sign of TenthGrid is negative), at line 4 (functiongeomButtOrOver invoked rather than function geomAvoiding), and at line 8(“coincident” argument specified instead of “butting” argument).

[0164] Spacing Rule Check Among Multi Wide Class Objects

[0165] As described above, objects in each wide class are not realgeometries, but are derived from the original geometries. A given wideobject may contain one or more virtual edges and virtual vertices,collectively referred to virtual boundaries. It is important to developan algorithm to perform a spacing design rule check among multi wideclass objects which deals with those virtual edges and virtual verticesto prevent false errors or a false positive (false pass).

[0166] To implement an exemplary algorithm, the wide class object sets(i.e., wide classes of objects) are derived for the layer to be checkedand are represented, as before, as w₀, w₁, w₂, . . . , w_(n). A spacingcheck is preferably performed by checking all w₀ object edges andvertices against other w₀ objects, since there are no virtual boundarieson w₀ objects. Any violation at this operation is real violation and canbe flagged as such. While not required, it is convenient to considerchecking the original geometries (i.e., w₀ objects) first.

[0167] In addition, each wide object class w_(i) is checked against thew₀ objects, but only the real boundaries are considered. In other words,the real edges and vertices of each higher class object w_(l) is checkedagainst the w₀ objects. This ensures that a spacing violation representsa violation between two original geometries or between two edges of anoriginal geometry, and that virtual edges are not flagged as violations.Generally, each of the higher class objects w₁, w₂, . . . , w_(n) ischecked against the w₀ object class, and any checks between or amonghigher class objects (w₁, w₂, . . . , w_(n)) is unnecessary. Forexample, a w₂ object does not need to be compared to another w₂ object,nor to any w₁ objects.

[0168] In a preferred embodiment described below, the w₀ class ischecked against itself using its respective spacing rule, then the w₁objects are checked against the w₀ objects using its respective wideclass spacing rule, then the w₂ objects are checked against the w₀objects using its respective wide class spacing rule, and continuinguntil the w_(n) objects are checked against the w₀ objects using itsrespective wide class spacing rule. If the various object classes areall derived, these checks may be performed in any order, although it isconvenient to check each class in increasing order.

[0169] As with traditional spacing checks, the ability to recognize a“notch” formed by edges of a single geometry, and to test the notch asif it were an external spacing between two objects using an externalspacing rule, is very desirable. When testing the w₀ objects, such anotch test is preferably incorporated. In the described exemplarytechniques, such a notch is recognized by checking w₀ edges againstother w₀ edges. But if a derived higher class object contains a notch, aspecific notch test for the higher class object may not be required. Forexample, by checking the real edges of a w_(i) class object against anyw₀ edges, a notch in a w_(i) object that is formed on both sides by real(i.e., non-virtual) w_(l) edges means that the edges forming such anotch are also w₀ edges, and will be tested by checking the real w_(i)edges against w₀ object edges.

[0170] When performing the corner-to-corner check, a check box of anappropriate size (corresponding to the w_(i) corner spacing rule) ispreferably generated at each non-virtual vertex of a given w_(i) object,and any wobjects which overlap a check box are flagged as violations.Such check boxes are not generated at the virtual vertices of the w_(i)objects, and consequently false errors will not be generated at thevirtual vertices.

[0171] The following exemplary DIVA code may be used to perform a w_(x)spacing rule check:

[0172] 1 edge_ck=geomGetEdge(wmt coincident w0)

[0173] 2 error_sep=drc(edge_ck w0 0<sep<ClassSpacing opposite)

[0174] 3 sprintf(mes_err “%s %s spacing<%0.2f” Rule Mt ClassSpacing)

[0175] 4 saveDerived(error_sep mes_err)

[0176] 5 BaseClass=geomCat(w0)

[0177] 6 StchSize=ClassSpacing

[0178] 7 InEdge=geomCat(edge_ck)

[0179] 8 load(“convex_stch.rul”)

[0180] 9 edge_stch_box=geomSize(edge_v_stch ClassSpacing)

[0181] 10 error_box=geomOverlap(edge_stch_box w0)

[0182] 11 sprintf(mes_err “%s %s dead zone<%0.2f” Rule Mt ClassSpacing)

[0183] 12 saveDerived(error_box mes₁₃ err)

[0184] The above code statements represent a spacing rule check modulethat may be referred to as SpacingRule.rul by other code segmentsherein, and for any wide class spacing check in an overall rule checkflow.

[0185] In line 1 above, the layer wmt represents the w_(l) object layerto be checked against the w₀ object layer, and the edge_ck layer isgenerated as the w_(i) object edges that are coincident with the w₀object edges (i.e., the real edges of the w_(i) objects). In code line 2a separation check is performed between opposite edges of the wmt layerand the w₀ layer, using a respective spacing rule ClassSpacing for thew_(i) object class. In code line 3, a textual error message is formattedusing the current values of certain variables, which message is attachedto each identified error from the edge separation test and the errorlayer error_sep saved in line 4.

[0186] Lines 5-7 set the value for certain arguments BaseClass,StchSize, and InEdge, and then invoke the convex_stch routine (describedabove) to stretch the w_(i) edge segments forming a non-virtual vertex.In line 9 these stretched edge segments edge_v_stch are sized into acheck box created on the edge_stch_box layer, and then in line 10 anysuch check box overlapping a w₀ object is identified and written to aerror_box layer. In code line 11, a textual error message is formattedusing the current values of certain variables, which message is attachedto each identified error box from the overlap test and the error layererror_box saved in line 12.

[0187] In general, for an n wide class design technology, an exemplaryspacing design rule check that includes a corner to corner spacing checkmay advantageously invoke the above SpacingRule.rul module for eachobject class to be tested, as in the following exemplary DIVA code:

[0188] 1 rule_file=sprintf(nil “%s/SpacingRule.rul” ruldrr)

[0189] 2 w0=geomCat(mt_good)

[0190] 3; Check w0 to w0

[0191] 4 wmt=geomCat(w0)

[0192] 5 ClassSpacing=MtxToMtx

[0193] 6 Rule=“Rx0”

[0194] 7 Mt=“mtx”

[0195] 8 load(rule_file)

[0196] 9; Check w1 to all classes

[0197] 10 wmt=geomCat(w1)

[0198] 11 ClassSpacing=MtxToMtxWide1

[0199] 12 Rule=“Rx1”

[0200] 13 Mt=“wide1 mtx”

[0201] 14 load(rule_file)

[0202] 15; Check wi to all classes

[0203] 16 wmt=geomCat(wm)

[0204] 17 ClassSpacing=MtxToMtxWidem

[0205] 18 Rule=“Rxi”

[0206] 19 Mt=“Widei mtx”

[0207] 20 load(rule_file)

[0208] 21; Check wn−1 to all classes

[0209] 22 wmt=geomCat(wn−1)

[0210] 23 ClassSpacing=MtxToMtxWiden−1

[0211] 24 Rule=“Rxn−1”

[0212] 25 Mt=“Widen−1 mtx”

[0213] 26 load(rule_file)

[0214] 27; Check wn to all classes

[0215] 28 wmt=geomCat(wn)

[0216] 29 ClassSpacing=MtxToMtxWiden

[0217] 30 Rule=“Rxn”

[0218] 31 Mt=“Widen mtx”

[0219] 32 load(rule_file)

[0220] In line 4, the layer wmt is defined as the w₀ object layer, andin line 5 the associated spacing rule is loaded into the variableClassSpacing. In lines 6-7 the variables Rule and Mt are loaded withidentifying text for labeling any identified errors, and in line 8 theSpacingRule module is loaded and executed (as described above). Each ofthe next four blocks of code reassigns the layers and variables for thenext higher level object class, and invokes the SpacingRule module. Ascan be appreciated, each successively higher-order w_(i) object class ischecked against the w₀ object class.

[0221] Referring now to FIGS. 8A-8C, the results of such an exemplaryrule check which uses only the non-virtual edges and vertices of higherclass objects are contrasted against traditional techniques using allthe edges and vertices of the higher class objects. FIG. 8A shows fivegeometries on a given layer to be tested. One large w₀ object 301 isshown with four neighboring smaller w₀ objects 302, 303, 304, 305. FIG.8B shows the flagged errors that would result for a w_(i) class spacingcheck which uses all edges and vertices of the w_(i) object derived fromthe large w₀ object. All four non-w_(i) class small objects 302, 303,304, 305 are flagging as violations. FIG. 8C shows the flagged errorsthat result for a w_(i) class spacing check as described above whichuses only the virtual edges and virtual vertices of the higher classobject. Only two non-w_(i) class objects 304, 305 are shown flagging asviolations.

[0222] It should be appreciated that such a spacing check is preferablyimplemented using effective wide class objects (as defined herein), butmay also be implemented using wide class objects.

[0223] Enclosure Rule Check Among Multi Wide Class Objects

[0224] When a via is placed within a wide metal object, it may need moremetal enclosure than that of a via which is placed within a non-widemetal object. When a via is partially within wide metal area andpartially within a non-wide metal area, it may need different metalenclosure in each different area.

[0225] To aid in understanding, a metal 1 (m1) to via 1 (v1) enclosurecheck is used as an example to illustrate substantive differencesbetween exemplary algorithms which accommodate virtual boundaries of thewide objects, and traditional algorithms which typically treat the wideobject as if it were a real geometry (having no virtual edges orvertices). In the examples that follow, three wide classes w₀, w₁, andw₂ are described, but the same methods and techniques may be easilyextended to additional wide classes.

[0226] For any of the enclosure algorithms that follow, the wide objectsare derived for each wide class object set, preferably as describedabove. Nonetheless, unless the context requires otherwise, as usedherein a wide class object set may refer to both a wide class object setand/or an effective wide class object set.

[0227] An enclosure check is a common function that is available in mostEDA tools. This kind of check usually measures the enclosure ofgeometries on one layer by geometries on another layer. Frequently, thiskind of operation measures the distance between inside facing edges ofthe “enclosing” layer geometries to outside facing edges of geometrieson the “enclosed” layer. In DIVA, a metal1-to-vial enclosure check (m1enclosure of v1) check can be performed as follows:

enc_error=drc(m1 v1 enc<M1OverV1 “m1 enc v1 violation”)

[0228] This function checks whether the edges of the tested objects orgeometries are enclosed, not the objects or geometries themselves, anddoes not guarantee that a geometry on one layer is completely insideanother. Since this kind of check is only applied on the edges of thegiven layer objects, it has no idea of whether an object is a derivedwide object or an original geometry. Consequently, it also has no ideahow to distinguish whether an edge is a real edge or a virtual edge.

[0229] Such virtual edges may generate false errors when traditionaltechniques such as a simplistic enclosure function is performed on eachwide class object set. One traditional algorithm may be coded in DIVA asfollows:

[0230] 21 drc(w0 good_v1 enc<M1OverV1 “m1 enc v1<M1OverV1”)

[0231] 22 drc(w1 good_v1 enc<M1Wide1OverV1 “wide1 m1 encv1<M1Wide1OverV1”)

[0232] 23 drc(w2 good_v1 enc<M2Wide1OverV1 “wide2 m1 encv1<M1Wide2OverV1”)

[0233] FIGS. 9A-9C illustrate a false error that can be generated bythis traditional algorithm. Referring now to FIG. 9A, a metal geometry102 is shown with two vias 104, 106 placed within the geometry 102. FIG.9B shows the result of a traditional enclosure check of the w0 metalobjects, as coded at line 21 above. Both vias 104, 106 pass the testbecause both are enclosed by the w0 object by at least the requiredW0OverVx distance, shown here as a dashed line 108 (and coded at line 21as “M1OverV1”). Said differently, the distance between each via 104, 106and the closest edges of the w₀ object 102 is at least the W0OverVxdistance.

[0234]FIG. 9C shows the result of a traditional enclosure check of thew1 metal objects, as coded at line 22 above. Via 106 passes because itis totally outside the w1 object. However, via 104 fails because it isnot completely enclosed by the w1 object by at least the requiredW1OverVx distance, shown here as a dashed line 110, and is thus flaggedas a violation. In other words, at least one of the via 104 edges fallsoutside the area bounded by line 110 (which is inside the w_(l) objectby the W1OverVx distance), and is thus closer to the wide object w_(l)edge than the required enclosure amount. In this case, the violation isbetween a virtual edge 111 of the w1 object and one of the via 104edges. However, this is false violation of the rule since the via 104actually is enclosed by the required W1OverVx distance. In this case,some of the required metal enclosure of via 104 happens to fall outsidethe w1 object.

[0235] Another traditional algorithm may perform a w₁ enclosure rule onw₀ objects for those vias which are overlapping the w₁ objects.Exemplary DIVA code for this algorithm may be written as:

[0236] 31 drc(w0 good_v1 enc<M1OverV1 “m1 enc v1<M1OverV1”)

[0237] 32 v1 w1=geomOverlap(good_v1 w1)

[0238] 33 drc(w0 v1_w1 enc<M1Wide1OverV1 “wide1 m1 encv1<M1Wide1OverV1”)

[0239] 34 v1_w2=geomOverlap(v1_w1 w2)

[0240] 35 drc(w2 v1_w2 enc<M2Wide1OverV1 “wide2 m1 encv1<M1Wide2OverV1”)

[0241] FIGS. 10A-10C illustrate another kind of false error that can begenerated by this second traditional algorithm. Referring now to FIG.10A, a metal geometry 112 (also labeled w0) is shown with two vias 114,116 placed within the geometry 112. FIG. 10B shows the result of atraditional enclosure check of the w0 metal objects, as coded at line 31above. Both vias 114, 116 pass the test because both are enclosed by thew0 object by at least the required W0OverVx distance (coded at line 31as “M1OverV1”), and represented here as a dashed line 118.

[0242]FIG. 10C shows the result of performing a w₁ enclosure rule on w₀objects for those vias which are overlapping the w₁ objects, as coded atline 32-33 above. Both vias 114 and 116 at least partially overlap thew₁ object, and thus are both selected at line 32. Via 114 passes becauseit is completely enclosed by the w₀ object by at least the testedW1OverVx distance (coded at line 33 as “M1Wide1OverV1”). However, via116 fails the test because it is not completely enclosed by the w0object by at least the tested distance of W1OverVx, and is thus flaggedas a violation. However, this is false violation of the w₁ enclosurerule since the via 116 straddles a virtual edge 121 of the w₁ object andfalls partially outside the w₁ object. Such a via is not properlysubject to the w₁ rule. The via 116 enclosure by the w₀ object isproper, and no violation actually exists. In this case, some of the via116 happens to fall outside the w₁ object. The false error is generatedbecause the w₁ rule has been applied to the w₀ object.

[0243] An exemplary DIVA coding for an improved method is listed below:

[0244] 41 drc(w0 v1 enc<M1OverV1 “m1 enc v1<M1OverV1”)

[0245] 42 w1_edge=geomGetEdge(w1 coincident w0)

[0246] 43 drc(w1_edge good_v1 enc<M1Wide1OverV1 “wide m1 encv1<M1Wide1OverV1”)

[0247] 44 w_edge=geomGetEdge(w1 inside w0)

[0248] 45 w_edge_s=geomStretch(w_edge−M1Wide1OverV1)

[0249] 46 w_edge_st=geomAndNot(w_edge w_edge_s)

[0250] 47 ck_box=geomSize(w_edge_st−M1Wide1OverV1)

[0251] 48 via_out=geomOverlap(ck_box v1)

[0252] 49 saveDerived(via_out “wide m1 enc v1<M1Wide1OverV1”)

[0253] 50 w2_edge=geomGetEdge(w2 coincident w0)

[0254] 51 drc(w2_edge good_V1 enc<M1Wide2OverV1 “wide m1 encv1<M1Wide2OverV1”)

[0255] 52 w_edge=geomGetEdge(w2 inside w0)

[0256] 53 w_edge_s=geomStretch(w_edge−M1Wide2OverV1)

[0257] 54 w_edge_st=geomAndNot(w_edge w_edge_s)

[0258] 55 ck_box=geomSize(w_edge_st−M1Wide2OverV1)

[0259] 56 via_out=geomOverlap(ck_box v1)

[0260] 57 saveDerived(via_out “wide m1 enc v1<M1Wide2OverV1”)

[0261] FIGS. 11A-11C represent the results of such an exemplary coding.In FIG. 11A two vias 104, 106 are placed within a geometry 102. The w₁object derived from the geometry 102 is also shown, having a virtualedge 111 shown as a dashed line and having remaining non-virtual (i.e.,real) edges shown as solid bold lines. FIG. 11B shows the result of thetraditional enclosure check of the w₀ metal objects, as coded at line 41above, which is identical to that shown in FIG. 9A. Both vias 104, 106pass the test because both are enclosed by the w₀ object by at least therequired W0OverVx distance, shown here as a dashed line 108 (and codedat line 41 using the argument “M1OverV1”).

[0262] The code lines 42-49 are described in the context of FIG. 11C. Atline 42, the non-virtual edges (i.e., real edges) of the w₁ objects arelocated by selecting those w₁ object edges which coincide with the w₀object edges. At line 43, an enclosure test is performed to check properw₁ rule enclosure of the vias by the non-virtual edges just identified.This test will locate failing vias everywhere except possibly at or nearthe ends of each virtual edge.

[0263] In this embodiment a “keep out” box (also referred to as a keepout area) is created on the inside of the w₁ object at each end of a w₁virtual edge. These keep out boxes are the same size as the w₁ enclosurerule distance W1OverVx, and any via overlapping a keep out box is a trueerror. Other vias which may cross, or be close to, the virtual edge arenot true failing vias, and are not flagged as errors. The keep out boxesare generated at lines 44-47. At line 44, the virtual edges of the w₁objects are located by identifying w₁ object edges falling inside (notcoincident with) a w₀ object. In the example shown in FIG. 11A, virtualedge 111 will be selected by this step. Then, at line 45, the virtualedges are stretched inward by a negative amount equal to the w₁enclosure rule distance W1OverVx (coded in line 45 as M1Wide1OverV1),thus creating a “shortened” version of the virtual edges on the w_edge_slayer. At line 46, the portion of the virtual edges which extend pastthe shortened virtual edges are identified, using an ANDNOT function, toform a w_edge_st layer which represents just the end-most W1OverVxportion of each virtual edge. These end-most virtual edge segments arethen sized at line 47 by a negative amount (i.e., sized inward) equal tothe w₁ enclosure rule distance W1OverVx to build each keep out box 132,134.

[0264] Having now created the keep out boxes, any via which overlaps akeep out box is identified and written to a saved layer via_out with atext attribute identifying the particular error, as shown at lines48-49. In the example shown in FIG. 11C, both vias 104, 106 pass becauseneither overlaps either of keep out boxes 132 or 134, and both alsopassed the non-virtual edge enclosure test (line 42). No via enclosuretest is performed using the w₁ virtual edges. Instead, the keep outboxes (i.e., virtual edge end keep out areas) are generated to flag avia which either crosses or abuts a virtual edge and which is placed tooclose to a w₀ object corner, such as corner 136, which is not a w₁object corner (i.e., too close to a virtual edge end). A via whicheither crosses or abuts a virtual edge will not be tested by atraditional enclosure test because the outside edge of the via is eitherabutting or outside the virtual edge. Using a technique such as theexemplary algorithm described above, a via which either crosses or abutsa virtual edge will pass the enclosure test unless it falls too close toan end of the virtual edge.

[0265] At lines 50-57, an analogous test sequence is performed on the w₂objects, using a corresponding w₂ enclosure rule distance W2OverVx (andcoded as M1Wide2OverV1), and need not be separately described.

[0266] In general, this exemplary algorithm may be generalized for ndifferent wide class object sets represented as w₀, w₁, w₂, . . . w_(n).For a specific wide class i (1<i<=n), the algorithm can be described as:

[0267] 1. Select the non-virtual edges of the w_(i) objects.

[0268] 2. Perform the w_(i) enclosure rule check on those non-virtualedges.

[0269] 3. Create the virtual edge end keep out areas having the samesize as the w_(i) enclosure rule.

[0270] 4. Flag any via overlapping a keep out area as violating thew_(i) via enclosure rule.

[0271] 5. Repeat the above steps for the next higher wide class objects.

[0272] The above generalized algorithm may also be performed for the w₀objects, but since there are no virtual edges in w₀ objects, thealgorithm may be computationally simplified to merely performing the w₀enclosure rule check of the w₀ object edges.

[0273] For those verification tools which are not strong in edgeoperations, other algorithms may be used which accomplish the sameresult using generally only geometry operations. Referring now to FIGS.12A-12F, the operation of another exemplary algorithm is depicted usinggeometry operations to perform the via enclosure check.

[0274] In FIG. 12A, a w₀ object, and a wide class w₁ object derived fromthe w₀ object, are shown, along with a w₁ object virtual edge 141. Thisw₀ object is sized down by W₀OverVx to derive the object 140, therebyforming a w₀ violation region inside the w₀ object boundary but outsidethe sized down object 140 boundary. This w₀ violation region is alsoshown alone in FIG. 12D for clarity. The w₀ object is also sized down byW₁OverVx to derive the object 142, thereby forming a w₁ violation regioninside the w₁ object boundary but outside the sized down object 142.These two w₀ and w₁ violation regions are merged to form a desiredviolation region, good through w₁ objects, which is labeled 147 in FIG.12B.

[0275] Also shown in FIG. 14B is a wide class w₂ object derived from thew₀ object, along with a w₂ object virtual edge 145. The w₀ object isalso sized down by W2OverVx to derive an object 144, thereby forming aW2 violation region inside the w₀ object boundary but outside the sizeddown object 144 boundary. This w₂ violation region is also shown alonein FIG. 12F for clarity. This w₂ violation region is preferably mergedwith the earlier formed violation region 147 to form a desired violationregion, good through w₂ objects, which is labeled 148 in FIG. 12B. Asbefore, any via which encroaches this violation region is marked as atrue via enclosure error. Additional details of similar geometry-basedtechniques are described elsewhere herein.

[0276] Pure Fill Via Area Extraction in a Multi Wide Class Design

[0277] Electronic Design Automation (EDA) functions may be used toextract Pure Fill Via Areas (PFVA) for each metal layer. As used herein,a PFVA is an artificial object or geometry which has been pre-shrunkfrom the original geometry by the correct enclosure amount depending onwhether the PFVA is within a wide metal area. A via can be dropped(i.e., placed) anywhere within such a PFVA without violating therespective via metal enclosure rules. A Layer Pure Fill Via Area (LPFVA)is an area which meets the metal enclosure rule for the specific metallayer. In other words, a via can be placed anywhere inside the areawithout violating the specific metal enclosure design rule for any wideclass. A v_(x) PFVA is the common area of a mt_(x) LPFVA and a mt_(x+1)LPFVA. In this common area, a v_(x) via meets metal enclosure designrules for both metal layers mt_(x) and mt_(x+1) anywhere. A LPFVA may beused for filling vias into the area without violating a specific metallayer enclosure design rule. Similarly, a v_(x) PFVA may be used forfilling v_(x) vias into the area without violating a specific metallayer enclosure design rule on either the mt_(x) or mt_(x+1) metallayers. Automated procedures to reliably extract the PFVA in a multiwide class design layout have been difficult to develop, and additionalimprovements are needed.

[0278] In general, for a multi wide class design, if there are ndifferent wide classes with n different metal enclosure rules, we candefine wide metal enclosure rules as W₀OverVia, W₁OverVia, . . . ,WnOverVia to be applied on wide metal sets w₀, w₁ , . . . , w_(n),respectively.

[0279] To aid in understanding, the derivation of a PFVA for anarbitrary metal layer (mt_(x)) is used as an example to illustratesubstantive differences between exemplary algorithms, which accommodatevirtual boundaries of the wide objects, and traditional algorithms whichtypically treat the wide object as if it were a real geometry (having novirtual edges or vertices). In the examples that follow, three wideclasses w₀, w₁, and w₂ are described, but the same (or equivalent)methods and techniques may be easily extended to additional wideclasses.

[0280] For any of the algorithms that follow, the wide objects aretypically first derived for each wide class object set, although theycould alternatively be derived as the algorithm progresses. ExemplaryDIVA code segments are described elsewhere herein which may be employedto derive the effective wide class object sets w₀, w₁, and w₂ for ametal layer mt_(x). For the following algorithms, unless the contextrequires otherwise, a wide class object set may refer to both a wideclass object set and/or an effective wide class object set.

[0281] FIGS. 13A-13C illustrate a traditional algorithm which sizes eachwide class object as if it were a real geometry (having no virtual edgesor vertices). Because the metal enclosure amounts are different for eachwide class, the objects in each class should be sized or shrunk by adifferent amount. However, after sizing, virtual edges in the wide classobjects also have been moved inwards, and consequently part of the PFVAmight be lost by the operation. In addition, a fill area may beimproperly separated into multiple areas where the wide class objectsmeet. For example, FIG. 13A shows a geometry 402, from which is deriveda wide class w₁ object 404, shown in FIG. 13B. Also shown are twoobjects 406 which represent portions of the w₀ object which are outsideof the w₁ objects. If each of the derived w₁ objects; and the “w₀outside w₁” objects, are sized by its respective enclosure rule amount,the resulting areas 408 and 410 “pull apart” at the virtual boundariesof the w₁ object. It is preferred that these areas should instead bejoined across the boundary. Virtual edge techniques may be used toextract the PFVA's without separating them at virtual edges. Referringnow to FIG. 13D, a geometry 412 (i.e., a w₀ object) is shown, along withan object 414 that represents the w₀ class object 412 after sizing downby W₀OverVia to get the PFVA for the w₀ class. This PFVA (object 414)may be assumed to now be the Current Pure Fill Via Area (CPFVA), whichis now current as through the w₀ wide class objects.

[0282]FIG. 13E shows a derived wide class w_(l) (0<i<=n) object whichhas been sized (or shrunk) by the respective enclosure rule W_(i)OverViato get the PFVA (labeled 416) for the w_(i) class. This w_(l) class PFVA416 may be deducted from w_(i) objects to get the w_(l) class cuttingareas 418, which are then deducted from the CPFVA 412. Preferably,however, only the real boundaries of the wide class w_(i) objects shouldbe shrunk, and the w_(l) wide class virtual edges, which are inside thew₀ objects, should not have been shrunk. These areas may be added backto the CPFVA to properly account for the virtual edges, by firststretching the virtual edge segments of the w_(i) objectsby−W_(i)OverVia to derive stretched base edge segments (one of which islabeled 420). These segments are then sized inward, alsoby—W_(i)OverVia, to form w_(i) virtual edge compensation areas (one ofwhich is labeled 422), which may then be added to complete the CPFVAgood through the w_(i) layer (labeled as 424 in FIG. 13F). These virtualedge compensation areas are spaced a distance back from the ends of eachvirtual edge segment by the appropriate enclosure rule, and thus ensuresthat the via enclosure near corners of the w_(i) objects has beenproperly accounted for.

[0283] In one embodiment, a method of extracting a PFVA using such edgeoperations may be described as follows:

[0284] 1. Size down the w₀ objects by W0OverVia, to derive the CPFVA,which at this point is good for w₀ class objects.

[0285] 2. Size down w_(l) objects by WiOverVia (1<=i<=n), to derive thew_(l) PFVA, then deducting the w_(l) PFVA from the w_(i) objects to formthe w_(l) cutting areas.

[0286] 3. Stretch the w_(l) virtual edges by −W_(i)OverVia to form thebase edge segments for the w_(i) compensation areas.

[0287] 4. Size the base edge segments by −W_(i)Over Via to form w_(i)virtual edge compensation areas.

[0288] 5. Deduct the w_(i) cutting areas from CPFVA and add the w_(l)virtual edge compensation areas to the CPFVA. At this point the CPFVA isgood for up through the w_(l) objects.

[0289] As the above description implies, steps 2-5 are repeated for allclasses w_(l) up through w_(n). At this point the w_(n) CPFVA is goodfor up through the w_(n) objects, and becomes the final PFVA for thelayer. The actions recited in the above steps 2-5 may be performed in avariety of specific sequence orders, but the order described isexemplary. An exemplary DIVA coding which implements the above exemplaryalgorithm in generally the order described, for two classes of wideobjects w₁ and w₂, is as follows:

[0290] 21 v_area=geomSize(w₀−W0Overvia)

[0291] 22 wv_edge=geomGetEdge(w1 inside w0)

[0292] 23 wv_stch geomStretch(wv_edge−W1OverVia)

[0293] 24 wv_stch_box=geomSize(wv_stch−W1OverVia)

[0294] 25 wv_area=geomSize(w1−W1OverVia)

[0295] 26 wv_cut=geomAndNot(w1 wv_area)

[0296] 27 v_area=geomAndNot(v_area wv_cut)

[0297] 28 v_area=geomOr(v_area wv_stch_box)

[0298] 29 wv_edge=geomGetEdge(w2 inside w0)

[0299] 30 wv_stch=geomStretch(wv_edge−W2OverVia)

[0300] 31 wv_stch_box=geomSize(wv_stch−W2OverVia)

[0301] 32 wv_area=geomSize(w2−W2OverVia)

[0302] 33 wv_cut=geomAndNot(w2 wv_area)

[0303] 34 v_area=geomAndNot(v_area wv_cut)

[0304] 35 v_area=geomOr(v_area wv_stch_box)

[0305] In line 21, the CPFVA for the w₀ objects are derived, asexemplified by object 414 in FIG. 13D. In line 22 the w₁ object virtualedges are derived, and then stretched in line 23 to form the base edgesegments 420. The w₁ virtual edge compensation areas 422 are formed inline 24 by sizing the base edge segments inward by the respectiveenclosure rule. The w₁ PFVA objects (such as object 416) are derived inline 25, and the w₁ cutting areas derived in line 26. The w₁ cuttingareas (such as object 418) are deducted from the CPFVA in line 27, andthe w₁ virtual edge compensation areas (such as object 422) added to theCPFVA in line 28.

[0306] As the above coding makes clear, the various steps of thisalgorithm may be performed in many different orders. For example, thecutting areas may be derived before the virtual edge compensation areasare derived, and the cutting areas may be deducted from the CPFVA beforeor after the virtual edge compensation areas are derived.

[0307] The above algorithm uses edge operations advantageously toproperly account for the virtual edges of the w_(i) objects. For thoseEDA tools which are not strong in edge operations, other algorithms maybe used which accomplish the same result using generally only geometryoperations. Referring now to FIGS. 14A-14C, the operation of anotherexemplary algorithm is depicted using geometry operations to derive thePFVA.

[0308] In FIG. 14A, a w₀ object 431 is shown. This w₀ object is sizeddown by W0OverVia (i.e., sized by a negative amount −W0OverVia) toderive the CPFVA for the w₀ objects, labeled as object 432. In FIG. 14B,the w₀ object 431 is also sized down by W_(l)OverVia to derive a W₁PFVA,labeled as object 434. The desired PFVA 438, shown in FIG. 14C, may beformed by merging the portion of the w₀ PFVA falling outside the w₁objects (labeled 436) with those portions of the W₁PFVA falling insidethe w₁ objects. As before, the resultant PFVA properly accounts for theappropriate enclosure rule near the ends of w₁ virtual edge segments.

[0309] There are many geometric methods which may be utilized to performsuch an algorithm. One such exemplary algorithm may be generalized formore than one wide object class as follows:

[0310] 1. Size the w₀ objects by −W₀Over Via, to derive the CPFVA forthe w₀ objects (e.g., object 432 in FIG. 14A).

[0311] 2. For w_(l) (1<=i<=n), size those w₀ geometries which containw_(l) objects by −W_(l) OverVia, to derive WiPFVA areas (e.g., W₁PFVAobject 434 in FIG. 14B).

[0312] 3. Derive the non w_(i) objects by deducting the w_(i) objectsfrom w₀ objects.

[0313] 4. Get the current fill via area in the non w_(i) objects byANDING the non w_(i) objects and the CPFVA. The result may be termed aNW_(i)PFVA to stand for Non-W_(i) Pure Fill Via Area.

[0314] 5. Merge the W_(l)PFVA and the NW_(l)PFVA to derive the CPFVAgood through the w_(i) layer (the w_(l) CPFVA).

[0315] 6. Repeat the above steps 2-5 for the next higher wide class. Thefinal CPFVA is the resultant PFVA for all wide classes.

[0316] An exemplary DIVA coding of such an algorithm using geometryoperations follows:

[0317] 41 v_area=geomSize(w0−W0OverVia)

[0318] 42 wv_area=geomSize(geomOverlap(w₀ w1) −W1OverVia)

[0319] 43 w_non=geomAndNot(w0 w1)

[0320] 44 w0_area=geomAnd(v_area wv_non)

[0321] 45 v_area=geomOr(wv_area w0_area)

[0322] 46 wv_area=geomSize(geomOverlap(w0 w2) −W2OverVia)

[0323] 47 wv_non=geomAndNot(w0 w2)

[0324] 48 w1_area=geomAnd(v_area wv_non)

[0325] 49 v_area=geomOr(wv_area w1_area)

[0326] In line 41, the CPFVA for the w₀ objects are derived (asexemplified by object 432). In line 42 the w₀ objects which contain a w₁object are selected, and then sized down by W1OverVia to derive a W₁PFVA(as exemplified by object 434). In line 43, the w₀ object portions lyingoutside the w₁ objects are derived, which are then ANDed with the CPFVAin line 44 to derive those portions of the CPFVA lying outside the w₁objects (e.g., objects 436). Finally, in line 45 the W₁PFVA is merged(ORed) with the CPFVA lying outside the w₁ objects to form the desiredPFVA (e.g., object 438). It is unnecessary to discard the portion of theW₁PFVA lying outside of the w₁ objects before this last merge operationbecause the CPFVA lying outside the w₁ objects is larger than theW₁PFVA, and thus dictates the result.

[0327] Analogous lines 46-49 perform similar operations for the w₂object class. In line 46 the w₀ objects which contain a w₂ object areselected, and then sized down by W2OverVia to derive the W₂PFVA. In line43, the w₀ object portions lying outside the w₂ objects are derived,which are then ANDed with the CPFVA in line 48 to derive those portionsof the CPFVA lying outside the w₂ objects. Finally, in line 49 theW₂PFVA is merged with the CPFVA lying outside the w₂ objects to form thedesired PFVA. In other words, the desired PFVA is formed by merging theportion of the w₁ PFVA falling outside the w₂ objects with the W₂PFVA.Alternatively, the desired PFVA may also be formed by merging theportion of the w₁ PFVA falling outside the w₂ objects with thoseportions of the W₂PFVA falling inside the w₂ objects. Such a portion ofthe W₂PFVA falling inside the w₂ objects may be termed as an effectiveW₂PFVA. Such an effective PFVA may be viewed as being created by sizingthe non-virtual boundary of the w₂ objects. The techniques describedherein may be used to define such a function of sizing the realboundaries of an object if such a function is not available in the CADtools of choice.

[0328] As we can see from the above examples, the operations arestandard for each wide class, therefore they are easy to implement asdesign rule modules to be used for all metal layers and vias.

[0329] Correction of Pure Fill Via Area Spacing Violations in a MultiWide Class Design

[0330] After the PFVA is extracted for a given layer, via spacingviolations may result relative to the existing vias or to another PFVAon the same layer. It is very desirable for such violations to beautomatically removed.

[0331] An exemplary technique for automatically correcting such viaspacing violations is depicted in FIGS. 15A-15F. Referring now to FIG.15A, a w₀ object 461 is shown, along with the PFVA 462 for the w₀ objectlayer, and several existing vias 463, 464, 465, 466. Each of these viasis preferably sized outward by the appropriate via spacing rule to formrespective via clearance areas 467, 468, 469, 470, shown in FIG. 15B.These via clearance areas are then deducted (i.e., “cut”) from the PFVA462 to form the resulting fill area 471 shown in FIG. 15C. Thus far, wehave ensured that a via placed within the resulting fill area 471 willsatisfy the via spacing rule relative to the existing vias, but as canbe seen, the fill area 471 may not be wide enough to hold a viaeverywhere within its boundaries. Consequently, those portions narrowerthan the width of a via are next eliminated from the fill area 471.Preferably this is accomplished by sizing down, then sizing back up,each fill area 471 by an amount equal to just slightly less than onehalf the via width, as described elsewhere herein. The resulting fillareas 474, 475 are depicted in FIG. 15D, which shows the narrow portions472, 473 (of width less than the VxWidth) as having been removed, andwhich results in two separate fill areas 474, 475.

[0332] The fill areas 474, 475 will hold a via placed anywhere withineither one without violating the via spacing rule to an existing via.But since the two areas 474, 475 lie closer to each other than the viaspacing rule near region 476, a via placed within area 474 may violatethe via spacing rule relative to a via placed nearby within area 476. Tocorrect such potential violations, a DRC check may be performed toidentify all the PFVA's which violate the via spacing rule relative toanother PFVA. In the exemplary FIG. 15D, both fill areas 474 and 475would be selected by such a DRC check. Then, all the edges from eacherroneous PFVA are selected. In addition, the edges forming convexvertices of the erroneous PFVA are also selected and stretched by anamount VxToVx, as shown in FIG. 15D, to cover corner to corner cases.Then, those edges and stretched edge segments are sized (outward) byVxToVx to form clearance areas for each PFVA , as shown in FIG. 15E.(The clearance area boundaries around fill area 474 and 475 are shown bydotted lines, except for the clearance areas formed by sizing thestretched edge segments from the convex vertices near region 476.) Theclearance areas 477 are then deducted from the PFVA to form the viaspacing violation free PFVA 480, 481, shown in FIG. 15F. Lastly, anyslivers in these PFVA areas 480, 481 (which may have been created inthese PFVA areas 480, 481 as a result of cutting the clearance areas)are removed, such as by preferably sizing down then sizing up by theappropriate amount. For example, if the edge 482 was shorter than thevia width, such a sliver would be removed by this last operation. Assome of these operations performed to correct certain violations maycreate other violations, such a method may be advantageously repeateduntil no errors remain.

[0333] A more generalized description of such a technique to make a PFVA“DRC-clean” to any existing via may be described as follows:

[0334] 1. Identify existing vias which violate the via spacing rule withthe PFVA's (either vias which are too close to a PFVA or which partiallyor fully overlap a PFVA).

[0335] 2. Size the identified existing vias by VxToVx to form existingvia clearance areas (e.g., FIG. 15B).

[0336] 3. Cut the existing via clearance areas from the PFVA (e.g., FIG.15C).

[0337] 4. Size down and size up the remaining PFVA byVxWidth/2−TenthGrid to remove any slivers which are not big enough tohold a single via (e.g., FIG. 15D).

[0338] A more generalized description of a technique to clean the DRCviolations among the PFVA's may be described as follows:

[0339] 1. Find all the PFVA's which violate the via spacing rule byperforming a DRC spacing check.

[0340] 2. Select all the edges from the erroneous PFVA's.

[0341] 3. Stretch the edges from convex vertices by VxToVx to covercorner to corner cases (e.g., stretched edge 478 shown in FIG. 15D).

[0342] 4. Sizing those selected edges and stretched edge segments byVxToVx to form clearance areas for each PFVA (e.g., clearance areas 477shown in FIG. 15E).

[0343] 5. Cut the clearance areas from PFVA's to form PFVA's which meetthe via spacing rule (e.g., FIG. 15F).

[0344] 6. Size down and size up these “post-cut” PFVA's byVxWidth/2−TenthGrid to get rid of any slivers which are not big enoughto hold a single via. This step may be optional depending upon the flow,because it might generate new spacing violations, but it will make theresultant PFVA easier to fill using an automated fill via process.

[0345] 7. Repeat the process as long as there is a spacing violationbetween two PFVA's.

[0346] After this DRC violation correction, the remaining PFVA's areready to fill with additional vias placed by a via fill process, whichmay be manual or performed by an automated design flow. In the exemplarytechnique described above, the EDA tool treats both erroneous geometriesequally, and the cutting areas generated by the flow (e,g., see FIG.15E) might result in a larger removed portion of the PFVA thanabsolutely necessary to meet the via spacing rule, but the benefits ofachieving correction of such violations in an automatic flow is believedto more than compensate for such an over-sized correction.

[0347] An exemplary DIVA code module to implement this algorithm for avia layer v₁ may be implemented as follows:

[0348] 61 v1=geomGetPurpose(“V1” “drawing”)

[0349] 62 vbd=geomGetPurpose(“V1” “boundary”)

[0350] 63 bad_v=drc(v1 vbd sep<V1ToV1 figa)

[0351] 64 bad_v_cut=geomsize(bad_v V1ToV1)

[0352] 65 vbd=geomAndNot(vbd bad_v_cut)

[0353] 66 size_f=V1Width/2−TenthGrid

[0354] 67 vbd=geomSize(geomSize(vbd−size_f) size_f)

[0355] 68 bad_vbd=drc(vbd sep<V1ToV1 fig)

[0356] 69 edge_ck=geomGetEdge(bad_vbd)

[0357] 70 InEdge=geomCat(edge_ck)

[0358] 71 BaseClass=geomCat(vbd)

[0359] 72 StchSize=V1ToV1

[0360] 73 load(“convex_stch.rul”)

[0361] 74 edge_ck=geomOr(edge_ck edge_v_stch)

[0362] 75 edge_ck_cut=geomSize(edge_ck V1ToV1)

[0363] 76 vbd=geomAndNot(vbd edge_ck_cut)

[0364] 77 size_f=V1Width/2−TenthGrid

[0365] 78 vbd=geomSize(geomSize(vbd−size_f) size_f)

[0366] In lines 61-62 the vias of interest are assigned to a derivedlayer v1 and the PFVA is also assigned to a derived layer vbd. In line63 the erroneous vias are identified, and then sized in line 64 by thevia-to-via spacing V1ToV1, and the sized vias cut from the PFVA, thusredefining the VBD layer (e.g., see FIG. 15C). At lines 66-67, theslivers in the VBD layer are removed.

[0367] In line 68 a DRC check is performed to identify all PFVA's whichviolate the via spacing rule, and the edges of the erroneous PFVA's areselected (i.e., written to a derived layer edge_ck) in line 69. At lines70-72 certain arguments are loaded in preparation for invoking (in line73) the “convex stretch” code module (described above) which stretchesthe edge segments forming the convex vertices of the PFVA's (e.g., FIG.15D) by an amount equal to the via spacing rule.

[0368] In lines 74-75 the stretched edge segments and the edge segmentsare both sized (i.e., outward) by the via spacing rule amount to formthe PFVA cutting areas, which are then deducted from the PFVA's in line76. Lastly, slivers in the resultant PFVA's narrower in width than a viaare removed in lines 77-78.

[0369] The above technique may be likened to a correction of a spacingviolation between objects of the same class, each having onlynon-virtual edges. In other words, a spacing violation between w₀objects. A similar technique for correcting spacing violation betweendummy (or other “non-design”) geometries having potentially higher classobjects defined by the non-design geometries includes stretching thenon-virtual edges and vertices of each w_(i) object to create cuttingareas which are deducted from nearby geometries, and is described inco-pending U.S. application Ser. No. 10/201,044 {Attomey Docket No.004-7540} filed Jul. 23, 2002, which application is hereby incorporatedherein by reference.

[0370] General Comments

[0371] The use of a convenient set nomenclature such as “a plurality ofwide class object sets w₀, w₁, w₂, . . . w_(n)” need not imply that nmust be greater than 2. Rather, n may be equal to 1, in which case thereneed be only one wide class of objects in addition to the originaldesign geometries themselves, which are represented by the w₀ class.Moreover. n may alternatively be equal to 2 or more than 2. In theexamples described, three wide classes w₀, w₁, and w₂ are described, butthe same methods and techniques may be easily extended to additionalwide classes.

[0372] As used herein, stretching an edge elongates the length of theedge while sizing an edge creates a rectangular area. Sizing istypically performed in the outward direction (i.e., “sizing up,” or awayfrom the center of the object), although at times may be toward thecenter of the object (i.e., “sizing down”).

[0373] It should be appreciated that operations discussed herein mayconsist of directly entered commands by a computer system user, but thepreferred embodiment includes steps executed by software modules. Thefunctionality of step referred to herein may correspond to thefunctionality of modules or portions of modules. In addition to softwaremodules, the above flows or portions of flows can be implemented asapplication instructions or menu items. For example, a sizing operationwhich only sizes non-virtual edges of an object by a sizing factor canbe an application instruction provided by an EDA tool provider accordingto some embodiments of the present invention.

[0374] The operations referred to herein may be modules or portions ofmodules (e.g., software, firmware, or hardware modules). For example,the software modules discussed herein may include script, batch or otherexecutable files, or combinations and/or portions of such files. Thesoftware modules may include a computer program or subroutines thereofencoded on computer-readable media.

[0375] Additionally, those skilled in the art will recognize that theboundaries between modules are merely illustrative and alternativeembodiments may merge modules or impose an alternative decomposition offunctionality of modules. For example, the modules discussed herein maybe decomposed into sub-modules to be executed as multiple computerprocesses. Moreover, alternative embodiments may combine multipleinstances of a particular module or sub-module. Furthermore, thoseskilled in the art will recognize that the operations described inexemplary embodiments are for illustration only. Operations may becombined or the functionality of the operations may be distributed inadditional operations in accordance with the invention. Line numbers onexemplary code sections or modules are used to uniquely identify eachline of code for ease of reference, and should not be taken to imply anyparticular required order between separately described modules, ornecessarily even within a module.

[0376] Thus, the flows described herein, the operations thereof andmodules therefore may be executed on a computer system configured toexecute the operations of the flows and/or may be executed fromcomputer-readable media. The flows may be embodied in a machine-readableand/or computer-readable medium for configuring a computer system toexecute the flows. Thus, the software modules may be stored withinand/or transmitted to a computer system memory to configure the computersystem to perform the functions of the module.

[0377] The flows described herein can be applied to an entire designlayout or portions thereof. For example, applying a flow to a smallerportion of a design layout can be performed to improve EDA toolperformance, or as portions of the design layout are completed, or whenonly a portion of the design layout needs an increased density, or anyother similar reason.

[0378] Although the above embodiments have been described in relation toCadence EDA tools and code segments utilizing Diva language code, thetechniques described herein can be applicable to and make use of any EDAtools, electronic circuit layout, and implemented in any code language.Moreover, although the above embodiments have been described in relationto integrated circuit layouts, the techniques described herein can beequally useful in the layout of other electronic devices, for example ina layout of a printed wiring board.

[0379] Realizations in accordance with the present invention have beendescribed in the context of particular embodiments. These embodimentsare meant to be illustrative and not limiting. Many variations,modifications, additions, and improvements are possible. Accordingly,plural instances may be provided for components described herein as asingle instance. Boundaries between various components, operations anddata stores are somewhat arbitrary, and particular operations areillustrated in the context of specific illustrative configurations.Other allocations of functionality are envisioned and may fall withinthe scope of claims that follow. Finally, structures and functionalitypresented as discrete components in the exemplary configurations may beimplemented as a combined structure or component. These and othervariations, modifications, additions, and improvements may fall withinthe scope of the invention as defined in the claims that follow.

What is claimed is:
 1. A method for deriving one or more pure fill viaareas (PFVA) for geometries on a first layer in a design layout havingmultiple wide class objects on the first layer, said method comprisingthe steps of: representing geometries on the first layer by a w₀ set ofobjects; sizing the w₀ objects inward by an associated via enclosurerule w₀ overV_(x) to generate a PFVA for the w₀ objects (w₀ PFVA);representing the w₀ PFVA as a current pure fill via area (CPFVA); foreach successive wide class of objects i=1, n corresponding to geometrieson the first layer: deriving the next higher numbered wide class objectset w_(i) corresponding to geometries on the first layer; eliminatingportions of the CPFVA lying inside the w_(i) objects and lying within adistance equal to an associated via enclosure rule w_(i) overV_(x) ofany non-virtual boundary of the w_(i) objects, to thereby form aresultant CPFVA valid for up to w_(i) objects (w_(l) CPFVA);representing the w_(n) CPFVA as the PFVA for the first layer.
 2. Themethod as recited in claim 1 wherein n is equal to
 1. 3. The method asrecited in claim 1 wherein the first layer comprises a metal layer of anintegrated circuit design layout.
 4. The method as recited in claim 1wherein the eliminating step to form the w_(i) CPFVA comprises:eliminating portions of the CPFVA lying inside the w_(i) objects andinside a region of the w_(i) object defined by its non-virtualboundaries and the end-most w_(i) overV_(x) portions of its virtualboundaries, said regions extending inward therefrom by a distance equalto w_(i) overV_(x).
 5. The method as recited in claim 1 wherein theeliminating step to form the w_(i) CPFVA comprises the steps of:deriving portions of the CPFVA lying outside the w_(l) objects as anon-w_(i) PFVA; deriving an effective PFVA for the w_(i) objects (w_(i)EPFVA); and merging the w_(i) EPFVA with the non-w_(i) PFVA to generatethe w_(l) CPFVA.
 6. The method as recited in claim 5 wherein thenon-w_(l) PFVA deriving step comprises: deducting w_(i) objects from thew₀ objects to generate non-w_(i) objects; and ANDing the non-w_(i)objects with the CPFVA.
 7. The method as recited in claim 5 wherein thew_(i) EPFVA deriving step comprises: sizing the w₀ objects inward byw_(i) overV_(x); and keeping portions of the sized w₀ objects which fallwithin the w_(l) objects to form the w_(i) EPFVA.
 8. The method asrecited in claim 7 wherein the step of sizing the w₀ objects inward byw_(i) overV_(x) comprises: sizing only those w₀ objects which contain aw_(i) object.
 9. The method as recited in claim 1 wherein theeliminating step to form the w_(l) CPFVA comprises: sizing the w_(i)objects inward by an associated via enclosure rule w_(i) overV_(x) togenerate a PFVA for the w_(i) objects (w_(l) PFVA); removing portions ofthe CPFVA which fall inside the w_(i) object but outside the w_(i) PFVA;adding w_(i) virtual edge compensation areas to the CPFVA.
 10. Themethod as recited in claim 9 wherein the virtual edge compensation areasare formed by shrinking each w_(l) object virtual edge by w_(i)overV_(x) to generate a base edge, and then sizing each base edge inwardby w_(i) overV_(x).
 11. The method as recited in claim 9 wherein theremoving step comprises: deducting the w_(i) PFVA from the w_(i) objectsto generate w_(l) cutting areas; and deducting the w_(i) cutting areasfrom the CPFVA.
 12. A method of making a computer readable media productthat encodes a design file representation of a design layout of anelectronic circuit, said design layout having multiple wide classobjects on the first layer, said method comprising the steps of:representing geometries on the first layer by a w₀ set of objects;sizing the w₀ objects inward by an associated via enclosure rule w₀overV_(x) to generate pure fill via areas (PFVA) for the w₀ objects (w₀PFVA); representing the w₀ PFVA as a current pure fill via area (CPFVA);for each successive wide class of objects i=1, n corresponding togeometries on the first layer: deriving the next higher numbered wideclass object set w_(i) corresponding to geometries on the first layer;eliminating portions of the CPFVA lying inside the w_(l) objects andlying within a distance equal to an associated via enclosure rule w_(i)overV_(x) of any non-virtual boundary of the w_(i) objects, to therebyform a resultant CPFVA valid for up to w_(i) objects (w_(i) CPFVA);representing the w_(n) CPFVA as the PFVA for the first layer; and usingthe PFVA for the first layer to indicate where vias may be placed. 13.The method as recited in claim 12 wherein n is equal to
 1. 14. Themethod as recited in claim 12 wherein the first layer comprises a metallayer of an integrated circuit design layout.
 15. The method as recitedin claim 12 wherein the eliminating step to form the w_(i) CPFVAcomprises: eliminating portions of the CPFVA lying inside the w_(i)objects and inside a region of the w_(i) object defined by itsnon-virtual boundaries and the end-most w_(i) overV_(x) portions of itsvirtual boundaries, said regions extending inward therefrom by adistance equal to w_(i) overV_(x).
 16. The method as recited in claim 12wherein the computer readable media product is embodied as one or moremedia selected from the set of a disk, tape, or other magnetic, optical,semiconductor or electronic storage medium and a network, wire line,wireless of other communications medium.
 17. A method of processing oneor more design files for an electronic circuit, the one or more designfiles encoding representations of a design layout of the electroniccircuit, the design layout having multiple wide class objects on a firstlayer, said method comprising the steps of: representing geometries onthe first layer by a w₀ set of objects; sizing the w₀ objects inward byan associated via enclosure rule w₀ overV_(x) to generate pure fill viaareas (PFVA) for the w₀ objects (w₀ PFVA); representing the w₀ PFVA as acurrent pure fill via area (CPFVA); for each successive wide class ofobjects i=1, n corresponding to geometries on the first layer: derivingthe next higher numbered wide class object set w_(i) corresponding togeometries on the first layer; eliminating portions of the CPFVA lyinginside the w_(i) objects and lying within a distance equal to anassociated via enclosure rule w_(i) overV_(x) of any non-virtualboundary of the w_(l) objects, to thereby form a resultant CPFVA validfor up to w_(l) objects (w_(i) CPFVA); representing the w_(n) CPFVA asthe PFVA for the first layer.
 18. The method as recited in claim 17wherein n is equal to
 1. 19. The method as recited in claim 17 whereinthe first layer comprises a metal layer of an integrated circuit designlayout.
 20. The method as recited in claim 17 wherein the eliminatingstep to form the w_(i) CPFVA comprises: eliminating portions of theCPFVA lying inside the w_(i) objects and inside a region of the w_(i)object defined by its non-virtual boundaries and the end-most w_(i)overV_(x) portions of its virtual boundaries, said regions extendinginward therefrom by a distance equal to w_(i) overV_(x).
 21. Anelectronic circuit fabricated from a design layout representationthereof, said design layout being generated by the steps of:representing geometries on the first layer by a w₀ set of objects;sizing the w₀ objects inward by an associated via enclosure rule w₀overV_(x) to generate pure fill via areas (PFVA) for the w₀ objects (w₀PFVA); representing the w₀ PFVA as a current pure fill via area (CPFVA);for each successive wide class of objects i=1, n corresponding togeometries on the first layer: deriving the next higher numbered wideclass object set w_(i) corresponding to geometries on the first layer;eliminating portions of the CPFVA lying inside the w_(l) objects andlying within a distance equal to an associated via enclosure rule w_(i)overV_(x) of any non-virtual boundary of the w_(l) objects, to therebyform a resultant CPFVA valid for up to w_(l) objects (w_(i) CPFVA);representing the w_(n) CPFVA as the PFVA for the first layer; and usingthe PFVA for the first layer to indicate where vias may be placed. 22.The electronic circuit as recited in claim 21 wherein n is equal to 1.23. The electronic circuit as recited in claim 21 wherein the firstlayer represents a metal layer of an integrated circuit design layout.24. The electronic circuit as recited in claim 21 wherein theeliminating step of the steps for generating the design layout comprisesthe step of: eliminating portions of the CPFVA lying inside the w_(i)objects and inside a region of the w_(i) object defined by itsnon-virtual boundaries and the end-most w_(i) overV_(x) portions of itsvirtual boundaries, said regions extending inward therefrom by adistance equal to w_(l) overV_(x).
 25. A computer readable encoding ofan electronic circuit design, the computer readable encoding comprising:one or more design file media encoding representations of a multiplewide object class design layout having geometries on a first layer;wherein the computer readable encoding of the electronic circuit designwas generated by the steps of: representing geometries on the firstlayer by a w₀ set of objects; sizing the w₀ objects inward by anassociated via enclosure rule w₀ overV_(x) to generate pure fill viaareas (PFVA) for the w₀ objects (w₀ PFVA); representing the w₀ PFVA as acurrent pure fill via area (CPFVA); for each successive wide class ofobjects i=1, n corresponding to geometries on the first layer: derivingthe next higher numbered wide class object set w_(i) corresponding togeometries on the first layer; eliminating portions of the CPFVA lyinginside the w_(l) objects and lying within a distance equal to anassociated via enclosure rule w_(l) overV_(x) of any non-virtualboundary of the w_(l) objects, to thereby form a resultant CPFVA validfor up to w_(i) objects (w_(l) CPFVA); representing the w_(n) CPFVA asthe PFVA for the first layer.
 26. The computer readable encoding asrecited in claim 25 wherein n is equal to
 1. 27. The computer readableencoding as recited in claim 25 wherein the first layer comprises ametal layer of an integrated circuit design layout.
 28. The computerreadable encoding as recited in claim 25 wherein the steps forgenerating the computer readable encoding of the electronic circuitdesign further comprise: eliminating portions of the CPFVA lying insidethe w_(i) objects and inside a region of the w_(l) object defined by itsnon-virtual boundaries and the end-most w_(i) overV_(x) portions of itsvirtual boundaries, said regions extending inward therefrom by adistance equal to w_(i) overV_(x) to form the w_(i) CPFVA.
 29. Anapparatus for processing one or more design files for an electroniccircuit, the one or more design files encoding representations of adesign layout of the electronic circuit, said apparatus comprising:means for representing geometries on the first layer by a w₀ set ofobjects; means for sizing the w₀ objects inward by an associated viaenclosure rule w₀ overV_(x) to generate pure fill via areas (PFVA) forthe w₀ objects (w₀ PFVA); means for representing the w₀ PFVA as acurrent pure fill via area (CPFVA); means for deriving the next highernumbered wide class object set w_(i) corresponding to geometries on thefirst layer; for each successive wide class of objects i=1, ncorresponding to geometries on the first layer: means for eliminatingportions of the CPFVA lying inside the w_(i) objects and lying within adistance equal to an associated via enclosure rule w_(l) overV_(x) ofany non-virtual boundary of the w_(l) objects, to thereby form aresultant CPFVA valid for up to w_(i) objects (w_(l) CPFVA); and meansfor representing the w_(n) CPFVA as the PFVA for the first layer. 30.The apparatus as recited in claim 29 wherein n is equal to
 1. 31. Theapparatus as recited in claim 29 wherein the means for eliminatingcomprises: means for eliminating portions of the CPFVA lying inside thew_(i) objects and inside a region of the w_(i) object defined by itsnon-virtual boundaries and the end-most w_(i) overV_(x) portions of itsvirtual boundaries, said regions extending inward therefrom by adistance equal to w_(i) overV_(x).
 32. A computer readable encoding ofinstructions for a computer, said instructions encoding a method for usewith a design layout, said encoded method for deriving one or more purefill via areas (PFVA) for geometries on a first layer in a design layouthaving multiple wide class objects on the first layer, said encodedmethod comprising the steps of: representing geometries on the firstlayer by a w₀ set of objects; sizing the w₀ objects inward by anassociated via enclosure rule w₀ overV_(x) to generate a PFVA for the w₀objects (w₀ PFVA); representing the w₀ PFVA as a current pure fill viaarea (CPFVA); for each successive wide class of objects i=1, ncorresponding to geometries on the first layer: deriving the next highernumbered wide class object set w_(i) corresponding to geometries on thefirst layer; eliminating portions of the CPFVA lying inside the w_(i)objects and lying within a distance equal to an associated via enclosurerule w_(i) overV_(x) of any non-virtual boundary of the w_(l) objects,to thereby form a resultant CPFVA valid for up to w_(i) objects (w_(l)CPFVA); representing the w_(n) CPFVA as the PFVA for the first layer.